home *** CD-ROM | disk | FTP | other *** search
/ LiquidLibrary 2005 February / LiquidLibrary 2005 February - Disc 1.iso / pc / Portfolio Browser / Filters / PDF / LIB / gs_cmap.ps < prev    next >
Text File  |  2003-01-03  |  14KB  |  444 lines
  1. %    Copyright (C) 1995, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile$ $Revision$
  7. % ProcSet for implementing CMap resources.
  8. % When this is run, systemdict is still writable.
  9.  
  10. % NOTE: Rearranged fonts are not implemented yet.
  11.  
  12. % ---------------- Public operators ---------------- %
  13.  
  14. /.rewriteTempMapsNotDef {
  15.   DEBUG { (rewriting TempMapsNotDef\n) print flush } if
  16.   .TempMaps 2 get
  17.   dup length 0 gt {
  18.     0 get
  19.     DEBUG { (...original...\n) print flush } if
  20.     1 5 2 index length 1 sub {
  21.       { 1 index exch get 2 3 put } stopped
  22.       { DEBUG { (cannot rewrite\n) print flush } if }
  23.       { DEBUG { (rewrite\n) print flush } if } ifelse
  24.     } for
  25.   } if
  26.   pop
  27.   DEBUG { (...FINISHED...\n) print } if
  28. } bind def
  29.  
  30. % composefont doesn't appear in CMap files -- it's documented in
  31. % the "PostScript Language Reference Manual Supplement".
  32. /composefont {        % <name> <cmap|cmapname> <fonts> composefont <font>
  33.   10 dict begin
  34.     /CMap 2 index dup type /dicttype ne { /CMap findresource } if def
  35.     /FDepVector 1 index cvlit def    % temporarily
  36.     /Encoding [ 0 1 FDepVector length 1 sub { } for ] def
  37.     /FDepVector [ 0 1 FDepVector length 1 sub {
  38.         % Stack: name cmap[name] fonts /FDepVector [ fonts... i
  39.       FDepVector 1 index get
  40.       dup type /dicttype ne {
  41.     dup /CIDFont resourcestatus {
  42.       pop pop /CIDFont
  43.     } {
  44.       /Font
  45.     } ifelse findresource
  46.       } if
  47.       exch CMap /FontMatrices get dup length 2 index gt {
  48.     exch get dup null eq { pop } { makefont } ifelse
  49.       } {
  50.     pop pop
  51.       } ifelse
  52.     } for ] readonly def
  53.     /FMapType 9 def
  54.     /FontMatrix matrix def
  55.     /FontName 3 index def
  56.     CMap /WMode .knownget { /WMode exch def } if
  57.     /FontType 0 def
  58.   pop pop currentdict end /Font defineresource
  59. } bind odef
  60.  
  61. % ---------------- CMap operators ---------------- %
  62.  
  63. 40 dict begin
  64.  
  65. % Our internal .CodeMapData structure closely mirrors the structures
  66. % defined in gxfcmap.h (q.v.).  () indicate a string, [] indicate an array,
  67. % ? indicates a Boolean, # indicates an integer, {} for grouping.
  68. %    [[(first) (last) ...]        % code space ranges
  69. %     [(prefix) (key_size,?is_range,value_type,value_size) (keys...)
  70. %       {(values...) | [value ...]} #font_index    % code mappings
  71. %      ...]
  72. %     <<same>>        % notdef mappings
  73. %    ]
  74. % FontMatrices is the array of matrices defined by begin/endusematrix.
  75. % All of the arrays and strings are read-only after they have been built.
  76. %
  77. % Note that the code in zfcmap.c that constructs the C structures from
  78. % the PostScript structures has intimate knowledge of the above format.
  79.  
  80. % ****** NOTE: The code currently only handles "well-behaved" CMaps:
  81. %    - CID values only (no bfchars), 16-bit
  82. %    - Entries (both code space and map) must be sorted
  83. %    - Only the last byte must vary in each map range, except for
  84. %    the identity mapping
  85.  
  86. % ------ Font-level operators ------ %
  87.  
  88. /begincmap {        % - begincmap -
  89.   /.CodeMapData [[] [] []] def
  90.   /FontMatrices [] def
  91.   /.FontIndex 0 def
  92.   /.TempMaps [20 dict 50 dict 50 dict] def
  93.   /CodeMap null def        % for .buildcmap
  94. } bind def
  95. /endcmap {        % - endcmap -
  96.   .rewriteTempMapsNotDef
  97.   DEBUG {
  98.     (*** defined charmap ***\n) print
  99.     .TempMaps 1 get {exch == (\t) print ==} forall
  100.     (*** undefined charmap ***\n) print
  101.     .TempMaps 2 get {exch == (\t) print ==} forall
  102.   } if
  103.   10 dict begin 0 1 2 {
  104.     /i exch def
  105.         % Append data from .TempMaps to .CodeMapData.
  106.     /t .TempMaps i get def
  107.     .CodeMapData i get length t { exch pop length add } forall
  108.     DEBUG { (requested array size ) print dup == } if
  109.     array /a exch def
  110.     a 0 .CodeMapData i get .putmore
  111.     0 1 t length 1 sub {
  112.       t exch get .putmore
  113.     } for pop pop
  114.     .CodeMapData i a put
  115.   } for end
  116.   currentdict /.TempMaps undef
  117.   /.CodeMapData .CodeMapData .endmap def
  118.   /FontMatrices FontMatrices .endmap def
  119. } bind def
  120.  
  121. /.putmore {        % <array> <i> <array2> .putmore <array> <i+len(array2)>
  122.   3 copy putinterval length add
  123. } bind def
  124.  
  125. /.endmap {        % <map> .endmap <map>
  126.   dup type /arraytype eq {
  127.     % This might be a shared read-only array inherited via usecmap.
  128.     % Don't try to update its elements if this is the case.
  129.     dup wcheck {
  130.       0 1 2 index length 1 sub {
  131.     2 copy 2 copy get .endmap put pop
  132.       } for readonly
  133.     } if
  134.   } {
  135.     dup type /stringtype eq { readonly } if
  136.   } ifelse
  137. } bind def
  138.  
  139. /.appendmap {        % -mark- <elt> ... <array#> .appendmap -
  140.   .TempMaps exch get counttomark 1 add 1 roll
  141.   ] 1 index length exch put
  142. } bind def
  143.  
  144. /begincodespacerange {    % <count> begincodespacerange -
  145.   pop mark
  146. } bind def
  147. /endcodespacerange {    % <code_lo> <code_hi> ... endcodespacerange -
  148.   0 .appendmap
  149. } bind def
  150.  
  151. /usecmap {        % <CMap_name> usecmap -
  152.   /CMap findresource dup
  153.         % Copy the top level of .CodeMapData
  154.   /.CodeMapData exch /.CodeMapData get copyarray def
  155.   /FontMatrices exch /FontMatrices get copyarray def
  156. } bind def
  157.  
  158. /usefont {        % <fontID> usefont -
  159.   /.FontIndex exch def
  160. } bind def
  161.  
  162. /beginusematrix {    % <fontID> beginusematrix -
  163.   FontMatrices wcheck not FontMatrices length 2 index le or {
  164.     FontMatrices length 1 index 1 add .max array
  165.     dup 0 FontMatrices putinterval
  166.     /FontMatrices exch def
  167.   } if
  168. } bind def
  169. /endusematrix {        % <matrix> endusematrix -
  170.   FontMatrices 3 1 roll put
  171. } bind def
  172.  
  173. % ------ Rearranged font operators ------ %
  174.  
  175. /beginrearrangedfont {    % <font_name> <font*> beginrearrangedfont -
  176.   10 dict begin
  177.   /.FontNames exch def
  178.   /.FontName exch def
  179.   begincmap
  180. } bind def
  181. /endrearrangedfont {    % - endrearrangedfont -
  182.   (REARRANGED FONTS NOT IMPLEMENTED YET.) = flush
  183.   FontName .FontNames 0 get findfont end definefont pop
  184. } bind def
  185.  
  186. % ------ Character name/code selector operators ------ %
  187.  
  188. /beginbfchar {        % <count> beginbfchar -
  189.   pop mark
  190. } bind def
  191. /endbfchar {        % <code> <to_code|charname> ... endbfchar
  192.   counttomark 2 idiv {
  193.     counttomark -2 roll        % process in correct order
  194.     .addbfchar
  195.   } repeat 1 .appendmap
  196. } bind def
  197.  
  198. /beginbfrange {        % <count> beginbfrange -
  199.   pop mark
  200. } bind def
  201. /endbfrange {        % <code_lo> <code_hi> <to_code|(charname*)> ...
  202.             %   endbfrange -
  203.   counttomark 3 idiv {
  204.     counttomark -3 roll        % process in correct order
  205.     dup type dup /arraytype eq exch /packedarraytype eq or {
  206.             % Array value, split up.
  207.       exch pop {
  208.             % Stack: code to_code|charname
  209.     1 index exch .addbfchar
  210.             % Increment the code.  As noted above, we require
  211.             % that only the last byte vary, but we still must
  212.             % mask it after incrementing, in case the last
  213.             % value was 0xff.
  214.             % Stack: code prefix params key value fontindex
  215.     6 -1 roll dup length string copy
  216.     dup dup length 1 sub 2 copy get 1 add 255 and put
  217.       } forall pop
  218.     } {
  219.             % Single value, handle directly.
  220.       .addbfrange
  221.     } ifelse
  222.   } repeat 1 .appendmap
  223. } bind def
  224.  
  225. /.addbfchar {        % <code> <to_code|charname> .addbfchar
  226.             %   <prefix> <params> <key> <value> <font_index>
  227.   1 index exch .addbfrange
  228. } bind def
  229. /.addbfrange {        % <code_lo> <code_hi> <to_code|charname>
  230.             %   .addbfrange <<same as .addbfchar>>
  231.   4 string dup 3
  232.   3 index type /nametype eq {
  233.     2 index 2 1 put
  234.     4 -1 roll 1 array astore 4 1 roll 4
  235.   } {
  236.     2 index 2 2 put
  237.     3 index length
  238.   } ifelse put
  239.             % Stack: code_lo code_hi value params
  240.   3 index 3 index eq {
  241.             % Single value.
  242.     3 -1 roll pop exch () exch
  243.   } {
  244.             % Range.
  245.     dup 0 1 put dup 1 1 put
  246.     4 2 roll
  247.     dup dup length 1 sub 0 exch getinterval 5 1 roll    % prefix
  248.             % Stack: prefix value params code_lo code_hi
  249.     2 { exch dup length 1 sub 1 getinterval } repeat concatstrings
  250.     3 -1 roll
  251.   } ifelse
  252.   .FontIndex
  253. } bind def
  254.  
  255. % ------ CID selector operators ------ %
  256.  
  257. /begincidchar {        % <count> begincidchar -
  258.   pop mark
  259. } bind def
  260. /endcidchar {        % <code> <cid> ... endcidchar -
  261.   1 .endmapchars
  262. } bind def
  263.  
  264. /begincidrange {    % <count> begincidrange -
  265.   pop mark
  266. } bind def
  267. /endcidrange {        % <code_lo> <code_hi> <cid_base> ... endcidrange -
  268.   1 .endmapranges
  269. } bind def
  270.  
  271. /.endmapchars {        % -mark- <code> <cid> ... <map#> .endmapchars -
  272.   counttomark 1 add 1 roll
  273.   counttomark 2 idiv {
  274.     counttomark -2 roll        % process in correct order
  275.         % Construct prefix, params, key, value, font_index
  276.     <00 00 00 02> ()    % params, key
  277.     3 -1 roll .endmapvalue
  278.   } repeat
  279.   counttomark 2 add -1 roll .appendmap
  280. } bind def
  281.  
  282. /.endmapranges {    % -mark- <code_lo> <code_hi> <cid_base> ... <map#>
  283.             %   .endmapranges -
  284.   counttomark 1 add 1 roll
  285.   counttomark 3 idiv {
  286.     counttomark -3 roll        % process in correct order
  287.         % Construct prefix, params, key_lo, key_hi, value, font_index
  288.     3 1 roll    % <cid_base> <code_lo> <code_hi>
  289.         %        prefix    key
  290.         % 1-byte code:    ()    .
  291.         % 1-byte range:    ()    .
  292.         % N-byte code:    .    (*)
  293.         % N-byte range:    (*)    (*)
  294.     dup 2 index eq {    % <code_lo> == <code_hi>
  295.                    % 0: prefix_len for 1-byte code
  296.                    % 1: prefix_len for N-byte code
  297.        dup length 1 eq { 0 } { 1 } ifelse
  298.     } {            % <code_lo> != <code_hi>
  299.                  % calculate prefix_len for *-byte range
  300.        dup length 1 sub % <cid_base> <code_lo> <code_hi> <code_len-1>
  301.        0        % initial value for N
  302.        {        % <cid_base> <code_lo> <code_hi> (code_len-1)  N
  303.            dup 2 index ge { exit } if % if (N >= len - 1) exit
  304.            3 index 1 index get    % N-th byte of code_lo
  305.            3 index 2 index get    % N-th byte of code_hi
  306.            eq { 1 add } { exit } ifelse
  307.        } loop
  308.        exch pop     % discard <code_len-1>
  309.     } ifelse
  310.                 % cid_base code_lo code_hi prefix_len
  311.  
  312.     % Althogh Adobe CPSI with native CID/CMap support accept
  313.     % multi-dimensional range specification in notdef & cidrange
  314.     % (and CID is calculated as relative position in multi-dimensional
  315.     % range), but older CPSI & ATM cannot handle it.
  316.     % 
  317.     % GS accepts such specification, but it's recommended to keep
  318.     % from using this feature for notdef & cidrange.
  319.     % Following is a disabler of this feature.
  320.     % -------------------------------------------------------------
  321.     % counttomark 1 add index     % get map#
  322.     % 0 ne {            % if not codespacerange
  323.     %   1 index length         % get code length
  324.     %   1 index             % get prefix length
  325.     %   sub            % calculate key length
  326.     %   1 gt {            % if (key_len > 1),
  327.     %      (.endmapranges error) = flush
  328.     %      (multi-dimensional range specification is used out of codespacerange)
  329.     %      = flush
  330.     %      (/) =only
  331.     %      CMapName CMapName length string cvs =only
  332.     %      (: <) =only
  333.     %      2 index (%stdout) (w) file exch writehexstring
  334.     %      (> <) =only
  335.     %      1 index (%stdout) (w) file exch writehexstring
  336.     %      (>\n) =only flush
  337.     %      quit
  338.     %   } if
  339.     % } if
  340.     % -------------------------------------------------------------
  341.  
  342.     1 index exch 0 exch getinterval
  343.                 % cid_base code_lo code_hi prefix
  344.     dup length 3 index length exch sub
  345.                 % cid_base code_lo code_hi prefix range_len
  346.     dup 255 gt {
  347.        (too long coderange specification for current GS\n) print stop
  348.     } if
  349.     <00 01 00 02> 4 string copy    % create initialized param
  350.     dup 0 4 -1 roll put        % put range_len into param
  351.  
  352.     % get key_hi
  353.     3 -1 roll dup length 3 index length dup 3 1 roll sub getinterval
  354.  
  355.     % get key_lo
  356.     4 -1 roll dup length 4 index length dup 3 1 roll sub getinterval
  357.  
  358.     % make "keys" (concatenated key_lo + key_hi)
  359.     exch concatstrings
  360.  
  361.     % 
  362.     4 -1 roll
  363.     .endmapvalue
  364.  
  365.         % See if we can merge with the previous value.
  366.         % The prefix, params, and font index must match.
  367.     % prefix params keys value fontindex
  368.     counttomark 5 gt { % 2 (or more) ranges (1 range = 5 item)
  369.        4 index 10 index eq    % compare prefix
  370.        4 index 10 index eq and    % compare params
  371.        1 index 7 index eq and    % compare fontindex
  372.     {
  373.           DEBUG { (merge!\n) print } if
  374.       pop 4 2 roll pop pop
  375.            % prefix params keys value fontindex keys2 value2
  376.       5 -1 roll 3 -1 roll concatstrings
  377.            % prefix params value fontindex value2 keys'
  378.       4 -1 roll 3 -1 roll concatstrings
  379.            % prefix params fontindex keys' values'
  380.       3 -1 roll
  381.     } if
  382.      } if % end of 2 (or more) ranges
  383.   } repeat
  384.   counttomark 2 add -1 roll .appendmap
  385. } bind def
  386.  
  387. /.endmapvalue {        % <cid> .endmapvalue (hi,lo) .FontIndex
  388.   2 string dup 0 3 index -8 bitshift put    % value
  389.   dup 1 4 -1 roll 255 and put
  390.   .FontIndex        % font_index
  391. } bind def
  392.  
  393. % ------ notdef operators ------ %
  394.  
  395. /beginnotdefchar {    % <count> beginnotdefchar -
  396.   pop mark
  397. } bind def
  398. /endnotdefchar {    % <code> <cid> ... endnotdefchar -
  399.   2 .endmapchars
  400. } bind def
  401.  
  402. /beginnotdefrange {    % <count> beginnotdefrange -
  403.   pop mark
  404. } bind def
  405. /endnotdefrange {    % <code_lo> <code_hi> <cid> ... endnotdefrange -
  406.   2 .endmapranges
  407. } bind def
  408.  
  409. % ---------------- Resource category definition ---------------- %
  410.  
  411. currentdict end
  412.  
  413. languagelevel exch 2 .setlanguagelevel
  414.  
  415. /CMap /Generic /Category findresource dup length dict .copydict
  416. dup /InstanceType /dicttype put
  417. dup /DefineResource {
  418.         % The AdobePS5 Windows driver emits code that attempts to
  419.         % create CMaps without the required CMapName entry.
  420.         % Work around this here.
  421.   dup /CMapName known not {
  422.     dup wcheck not {
  423.       .currentglobal exch dup wcheck .setglobal
  424.       dup length dict .copydict exch .setglobal
  425.     } if
  426.     dup gcheck 2 index gcheck not and {
  427.       exch .currentglobal exch true .setglobal
  428.       dup length string copy exch .setglobal exch
  429.     } if dup /CMapName 3 index put
  430.   } if
  431.   dup /CodeMap get null eq { .buildcmap } if
  432.   /Generic /Category findresource /DefineResource get exec
  433. } put
  434. /Category defineresource pop
  435.     % We might have loaded CID font support already.
  436. /CIDInit /ProcSet 2 copy { findresource } .internalstopped
  437.     % An interior `stopped' might have reset VM allocation to local.
  438. true .setglobal
  439.  { pop pop 3 -1 roll }
  440.  { dup length 4 index length add dict .copydict 4 -1 roll exch .copydict }
  441. ifelse exch defineresource pop
  442.  
  443. .setlanguagelevel
  444.